//! # 观测性配置管理模块
//! 
//! 提供观测性系统的配置定义和管理功能。
//! 支持采样策略、导出配置和组件启用控制。

use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::time::Duration;

/// 观测性配置
/// 
/// 统一管理所有观测性组件的配置参数。
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ObservabilityConfig {
    /// 是否启用指标收集
    pub metrics_enabled: bool,
    
    /// 是否启用分布式追踪
    pub tracing_enabled: bool,
    
    /// 是否启用日志记录
    pub logging_enabled: bool,
    
    /// 采样配置
    pub sampling: SamplingConfig,
    
    /// 默认标签配置
    pub default_labels: HashMap<String, String>,
    
    /// 导出配置
    pub export: ExportConfig,
    
    /// 性能配置
    pub performance: PerformanceConfig,
    
    /// 指标配置
    pub metrics: MetricsConfig,
    
    /// 追踪配置
    pub tracing: TracingConfig,
    
    /// 日志配置
    pub logging: LoggingConfig,
}

impl Default for ObservabilityConfig {
    fn default() -> Self {
        Self {
            metrics_enabled: true,
            tracing_enabled: true,
            logging_enabled: true,
            sampling: SamplingConfig::default(),
            default_labels: HashMap::new(),
            export: ExportConfig::default(),
            performance: PerformanceConfig::default(),
            metrics: MetricsConfig::default(),
            tracing: TracingConfig::default(),
            logging: LoggingConfig::default(),
        }
    }
}

/// 采样配置
/// 
/// 控制各种数据的采样率，用于性能优化。
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SamplingConfig {
    /// 追踪采样率 (0.0-1.0)
    pub trace_sampling_rate: f64,
    
    /// 指标采样率 (0.0-1.0)
    pub metrics_sampling_rate: f64,
    
    /// 日志采样率 (0.0-1.0)
    pub log_sampling_rate: f64,
    
    /// 采样策略
    pub strategy: SamplingStrategy,
    
    /// 自适应采样配置
    pub adaptive: Option<AdaptiveSamplingConfig>,
}

impl Default for SamplingConfig {
    fn default() -> Self {
        Self {
            trace_sampling_rate: 1.0,
            metrics_sampling_rate: 1.0,
            log_sampling_rate: 1.0,
            strategy: SamplingStrategy::Fixed,
            adaptive: None,
        }
    }
}

/// 采样策略
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum SamplingStrategy {
    /// 固定采样率
    Fixed,
    /// 自适应采样
    Adaptive,
    /// 基于优先级的采样
    PriorityBased,
    /// 基于负载的采样
    LoadBased,
}

/// 自适应采样配置
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AdaptiveSamplingConfig {
    /// 目标吞吐量（每秒样本数）
    pub target_throughput: u32,
    
    /// 调整间隔（秒）
    pub adjustment_interval_secs: u64,
    
    /// 最小采样率
    pub min_sampling_rate: f64,
    
    /// 最大采样率
    pub max_sampling_rate: f64,
}

/// 导出配置
/// 
/// 控制观测性数据的导出行为。
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ExportConfig {
    /// 批处理大小
    pub batch_size: usize,
    
    /// 导出间隔（毫秒）
    pub export_interval_ms: u64,
    
    /// 超时时间（毫秒）
    pub timeout_ms: u64,
    
    /// 重试配置
    pub retry: RetryConfig,
    
    /// 缓冲区配置
    pub buffer: BufferConfig,
}

impl Default for ExportConfig {
    fn default() -> Self {
        Self {
            batch_size: 100,
            export_interval_ms: 1000,
            timeout_ms: 5000,
            retry: RetryConfig::default(),
            buffer: BufferConfig::default(),
        }
    }
}

/// 重试配置
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RetryConfig {
    /// 最大重试次数
    pub max_attempts: u32,
    
    /// 初始重试间隔（毫秒）
    pub initial_delay_ms: u64,
    
    /// 最大重试间隔（毫秒）
    pub max_delay_ms: u64,
    
    /// 退避倍数
    pub backoff_multiplier: f64,
}

impl Default for RetryConfig {
    fn default() -> Self {
        Self {
            max_attempts: 3,
            initial_delay_ms: 1000,
            max_delay_ms: 30000,
            backoff_multiplier: 2.0,
        }
    }
}

/// 缓冲区配置
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BufferConfig {
    /// 最大缓冲区大小
    pub max_size: usize,
    
    /// 缓冲区满时的策略
    pub overflow_strategy: OverflowStrategy,
    
    /// 内存限制（字节）
    pub memory_limit_bytes: Option<usize>,
}

impl Default for BufferConfig {
    fn default() -> Self {
        Self {
            max_size: 10000,
            overflow_strategy: OverflowStrategy::DropOldest,
            memory_limit_bytes: Some(100 * 1024 * 1024), // 100MB
        }
    }
}

/// 缓冲区溢出策略
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum OverflowStrategy {
    /// 丢弃最旧的数据
    DropOldest,
    /// 丢弃最新的数据
    DropNewest,
    /// 阻塞直到有空间
    Block,
    /// 报告错误
    Error,
}

/// 性能配置
/// 
/// 观测性系统的性能调优参数。
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PerformanceConfig {
    /// 工作线程数
    pub worker_threads: Option<usize>,
    
    /// 队列大小
    pub queue_size: usize,
    
    /// 上下文清理间隔（秒）
    pub context_cleanup_interval_secs: u64,
    
    /// 上下文最大存活时间（秒）
    pub context_max_age_secs: u64,
    
    /// 启用零拷贝优化
    pub enable_zero_copy: bool,
    
    /// 启用批处理
    pub enable_batching: bool,
}

impl Default for PerformanceConfig {
    fn default() -> Self {
        Self {
            worker_threads: None, // 使用默认线程数
            queue_size: 1000,
            context_cleanup_interval_secs: 300, // 5分钟
            context_max_age_secs: 3600,         // 1小时
            enable_zero_copy: true,
            enable_batching: true,
        }
    }
}

/// 指标配置
/// 
/// 指标收集的专用配置。
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MetricsConfig {
    /// 启用内置指标
    pub enable_builtin_metrics: bool,
    
    /// 指标前缀
    pub metric_prefix: String,
    
    /// 直方图桶配置
    pub histogram_buckets: Vec<f64>,
    
    /// 指标标签限制
    pub max_labels_per_metric: usize,
    
    /// 指标名称模式
    pub allowed_metric_patterns: Vec<String>,
    
    /// 聚合间隔（秒）
    pub aggregation_interval_secs: u64,
}

impl Default for MetricsConfig {
    fn default() -> Self {
        Self {
            enable_builtin_metrics: true,
            metric_prefix: "rustcloud".to_string(),
            histogram_buckets: vec![0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1.0, 2.5, 5.0, 10.0],
            max_labels_per_metric: 20,
            allowed_metric_patterns: vec!["*".to_string()],
            aggregation_interval_secs: 60,
        }
    }
}

/// 追踪配置
/// 
/// 分布式追踪的专用配置。
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TracingConfig {
    /// 启用自动span创建
    pub enable_auto_span: bool,
    
    /// 最大span深度
    pub max_span_depth: u32,
    
    /// span属性限制
    pub max_attributes_per_span: usize,
    
    /// span事件限制
    pub max_events_per_span: usize,
    
    /// 链路属性
    pub trace_attributes: HashMap<String, String>,
    
    /// 资源属性
    pub resource_attributes: HashMap<String, String>,
}

impl Default for TracingConfig {
    fn default() -> Self {
        Self {
            enable_auto_span: true,
            max_span_depth: 50,
            max_attributes_per_span: 100,
            max_events_per_span: 100,
            trace_attributes: HashMap::new(),
            resource_attributes: HashMap::new(),
        }
    }
}

/// 日志配置
/// 
/// 日志系统的专用配置。
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct LoggingConfig {
    /// 默认日志级别
    pub default_level: String,
    
    /// 模块日志级别配置
    pub module_levels: HashMap<String, String>,
    
    /// 启用结构化日志
    pub enable_structured: bool,
    
    /// 日志格式
    pub format: LogFormat,
    
    /// 输出目标配置
    pub outputs: Vec<LogOutput>,
    
    /// 字段过滤器
    pub field_filters: Vec<String>,
}

impl Default for LoggingConfig {
    fn default() -> Self {
        Self {
            default_level: "info".to_string(),
            module_levels: HashMap::new(),
            enable_structured: true,
            format: LogFormat::Json,
            outputs: vec![LogOutput::Stdout],
            field_filters: Vec::new(),
        }
    }
}

/// 日志格式
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum LogFormat {
    /// JSON格式
    Json,
    /// 紧凑格式
    Compact,
    /// 完整格式
    Full,
    /// 自定义格式
    Custom(String),
}

/// 日志输出目标
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum LogOutput {
    /// 标准输出
    Stdout,
    /// 标准错误输出
    Stderr,
    /// 文件输出
    File(FileOutputConfig),
    /// 网络输出
    Network(NetworkOutputConfig),
}

/// 文件输出配置
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct FileOutputConfig {
    /// 文件路径
    pub path: String,
    
    /// 文件轮转配置
    pub rotation: Option<FileRotationConfig>,
    
    /// 压缩配置
    pub compression: Option<CompressionConfig>,
}

/// 文件轮转配置
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct FileRotationConfig {
    /// 最大文件大小（字节）
    pub max_size_bytes: u64,
    
    /// 最大文件数量
    pub max_files: u32,
    
    /// 轮转间隔
    pub rotation_interval: Option<String>,
}

/// 压缩配置
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CompressionConfig {
    /// 压缩算法
    pub algorithm: CompressionAlgorithm,
    
    /// 压缩级别
    pub level: Option<u32>,
}

/// 压缩算法
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum CompressionAlgorithm {
    Gzip,
    Zstd,
    Lz4,
}

/// 网络输出配置
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct NetworkOutputConfig {
    /// 目标地址
    pub endpoint: String,
    
    /// 协议类型
    pub protocol: NetworkProtocol,
    
    /// 认证配置
    pub auth: Option<NetworkAuthConfig>,
    
    /// TLS配置
    pub tls: Option<TlsConfig>,
}

/// 网络协议
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum NetworkProtocol {
    Http,
    Https,
    Tcp,
    Udp,
    Grpc,
}

/// 网络认证配置
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct NetworkAuthConfig {
    /// 认证类型
    pub auth_type: AuthType,
    
    /// 用户名
    pub username: Option<String>,
    
    /// 密码
    pub password: Option<String>,
    
    /// Token
    pub token: Option<String>,
    
    /// API密钥
    pub api_key: Option<String>,
}

/// 认证类型
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum AuthType {
    None,
    Basic,
    Bearer,
    ApiKey,
    Custom(String),
}

/// TLS配置
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TlsConfig {
    /// 启用TLS
    pub enabled: bool,
    
    /// 证书文件路径
    pub cert_file: Option<String>,
    
    /// 私钥文件路径
    pub key_file: Option<String>,
    
    /// CA证书文件路径
    pub ca_file: Option<String>,
    
    /// 跳过证书验证
    pub insecure_skip_verify: bool,
}

impl ObservabilityConfig {
    /// 验证配置的有效性
    /// 
    /// # 返回值
    /// 配置有效返回Ok(())，否则返回错误信息
    pub fn validate(&self) -> Result<(), String> {
        // 验证采样率
        if !(0.0..=1.0).contains(&self.sampling.trace_sampling_rate) {
            return Err("追踪采样率必须在0.0到1.0之间".to_string());
        }
        
        if !(0.0..=1.0).contains(&self.sampling.metrics_sampling_rate) {
            return Err("指标采样率必须在0.0到1.0之间".to_string());
        }
        
        if !(0.0..=1.0).contains(&self.sampling.log_sampling_rate) {
            return Err("日志采样率必须在0.0到1.0之间".to_string());
        }
        
        // 验证导出配置
        if self.export.batch_size == 0 {
            return Err("批处理大小必须大于0".to_string());
        }
        
        if self.export.export_interval_ms == 0 {
            return Err("导出间隔必须大于0".to_string());
        }
        
        // 验证性能配置
        if self.performance.queue_size == 0 {
            return Err("队列大小必须大于0".to_string());
        }
        
        Ok(())
    }
    
    /// 获取上下文清理间隔
    /// 
    /// # 返回值
    /// Duration对象
    pub fn context_cleanup_interval(&self) -> Duration {
        Duration::from_secs(self.performance.context_cleanup_interval_secs)
    }
    
    /// 获取上下文最大存活时间
    /// 
    /// # 返回值
    /// Duration对象
    pub fn context_max_age(&self) -> Duration {
        Duration::from_secs(self.performance.context_max_age_secs)
    }
    
    /// 获取导出间隔
    /// 
    /// # 返回值
    /// Duration对象
    pub fn export_interval(&self) -> Duration {
        Duration::from_millis(self.export.export_interval_ms)
    }
    
    /// 获取导出超时时间
    /// 
    /// # 返回值
    /// Duration对象
    pub fn export_timeout(&self) -> Duration {
        Duration::from_millis(self.export.timeout_ms)
    }
}